#include <sstream>
#include "ExcitationSystemDynamics.hpp"
#include "ExcREXS.hpp"

#include "PU.hpp"
#include "PU.hpp"
#include "ExcREXSFeedbackSignalKind.hpp"
#include "PU.hpp"
#include "PU.hpp"
#include "PU.hpp"
#include "PU.hpp"
#include "PU.hpp"
#include "Seconds.hpp"
#include "PU.hpp"
#include "PU.hpp"
#include "PU.hpp"
#include "PU.hpp"
#include "PU.hpp"
#include "PU.hpp"
#include "PU.hpp"
#include "PU.hpp"
#include "PU.hpp"
#include "PU.hpp"
#include "Seconds.hpp"
#include "Seconds.hpp"
#include "Seconds.hpp"
#include "Seconds.hpp"
#include "Seconds.hpp"
#include "Seconds.hpp"
#include "Seconds.hpp"
#include "Seconds.hpp"
#include "Seconds.hpp"
#include "Seconds.hpp"
#include "PU.hpp"
#include "PU.hpp"
#include "PU.hpp"
#include "PU.hpp"
#include "PU.hpp"
#include "PU.hpp"
#include "PU.hpp"

using namespace CIMPP;

ExcREXS::ExcREXS() {};

ExcREXS::~ExcREXS() {};







































bool assign_ExcREXS_e1(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(ExcREXS* element = dynamic_cast<ExcREXS*>(BaseClass_ptr1)) {
                buffer >> element->e1;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_ExcREXS_e2(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(ExcREXS* element = dynamic_cast<ExcREXS*>(BaseClass_ptr1)) {
                buffer >> element->e2;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_ExcREXS_fbf(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(ExcREXS* element = dynamic_cast<ExcREXS*>(BaseClass_ptr1)) {
                buffer >> element->fbf;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_ExcREXS_flimf(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(ExcREXS* element = dynamic_cast<ExcREXS*>(BaseClass_ptr1)) {
                buffer >> element->flimf;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_ExcREXS_kc(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(ExcREXS* element = dynamic_cast<ExcREXS*>(BaseClass_ptr1)) {
                buffer >> element->kc;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_ExcREXS_kd(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(ExcREXS* element = dynamic_cast<ExcREXS*>(BaseClass_ptr1)) {
                buffer >> element->kd;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_ExcREXS_ke(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(ExcREXS* element = dynamic_cast<ExcREXS*>(BaseClass_ptr1)) {
                buffer >> element->ke;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_ExcREXS_kefd(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(ExcREXS* element = dynamic_cast<ExcREXS*>(BaseClass_ptr1)) {
                buffer >> element->kefd;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_ExcREXS_kf(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(ExcREXS* element = dynamic_cast<ExcREXS*>(BaseClass_ptr1)) {
                buffer >> element->kf;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_ExcREXS_kh(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(ExcREXS* element = dynamic_cast<ExcREXS*>(BaseClass_ptr1)) {
                buffer >> element->kh;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_ExcREXS_kii(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(ExcREXS* element = dynamic_cast<ExcREXS*>(BaseClass_ptr1)) {
                buffer >> element->kii;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_ExcREXS_kip(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(ExcREXS* element = dynamic_cast<ExcREXS*>(BaseClass_ptr1)) {
                buffer >> element->kip;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_ExcREXS_ks(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(ExcREXS* element = dynamic_cast<ExcREXS*>(BaseClass_ptr1)) {
                buffer >> element->ks;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_ExcREXS_kvi(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(ExcREXS* element = dynamic_cast<ExcREXS*>(BaseClass_ptr1)) {
                buffer >> element->kvi;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_ExcREXS_kvp(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(ExcREXS* element = dynamic_cast<ExcREXS*>(BaseClass_ptr1)) {
                buffer >> element->kvp;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_ExcREXS_kvphz(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(ExcREXS* element = dynamic_cast<ExcREXS*>(BaseClass_ptr1)) {
                buffer >> element->kvphz;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_ExcREXS_nvphz(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(ExcREXS* element = dynamic_cast<ExcREXS*>(BaseClass_ptr1)) {
                buffer >> element->nvphz;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_ExcREXS_se1(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(ExcREXS* element = dynamic_cast<ExcREXS*>(BaseClass_ptr1)) {
                buffer >> element->se1;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_ExcREXS_se2(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(ExcREXS* element = dynamic_cast<ExcREXS*>(BaseClass_ptr1)) {
                buffer >> element->se2;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_ExcREXS_ta(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(ExcREXS* element = dynamic_cast<ExcREXS*>(BaseClass_ptr1)) {
                buffer >> element->ta;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_ExcREXS_tb1(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(ExcREXS* element = dynamic_cast<ExcREXS*>(BaseClass_ptr1)) {
                buffer >> element->tb1;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_ExcREXS_tb2(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(ExcREXS* element = dynamic_cast<ExcREXS*>(BaseClass_ptr1)) {
                buffer >> element->tb2;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_ExcREXS_tc1(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(ExcREXS* element = dynamic_cast<ExcREXS*>(BaseClass_ptr1)) {
                buffer >> element->tc1;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_ExcREXS_tc2(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(ExcREXS* element = dynamic_cast<ExcREXS*>(BaseClass_ptr1)) {
                buffer >> element->tc2;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_ExcREXS_te(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(ExcREXS* element = dynamic_cast<ExcREXS*>(BaseClass_ptr1)) {
                buffer >> element->te;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_ExcREXS_tf(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(ExcREXS* element = dynamic_cast<ExcREXS*>(BaseClass_ptr1)) {
                buffer >> element->tf;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_ExcREXS_tf1(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(ExcREXS* element = dynamic_cast<ExcREXS*>(BaseClass_ptr1)) {
                buffer >> element->tf1;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_ExcREXS_tf2(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(ExcREXS* element = dynamic_cast<ExcREXS*>(BaseClass_ptr1)) {
                buffer >> element->tf2;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_ExcREXS_tp(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(ExcREXS* element = dynamic_cast<ExcREXS*>(BaseClass_ptr1)) {
                buffer >> element->tp;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_ExcREXS_vcmax(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(ExcREXS* element = dynamic_cast<ExcREXS*>(BaseClass_ptr1)) {
                buffer >> element->vcmax;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_ExcREXS_vfmax(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(ExcREXS* element = dynamic_cast<ExcREXS*>(BaseClass_ptr1)) {
                buffer >> element->vfmax;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_ExcREXS_vfmin(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(ExcREXS* element = dynamic_cast<ExcREXS*>(BaseClass_ptr1)) {
                buffer >> element->vfmin;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_ExcREXS_vimax(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(ExcREXS* element = dynamic_cast<ExcREXS*>(BaseClass_ptr1)) {
                buffer >> element->vimax;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_ExcREXS_vrmax(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(ExcREXS* element = dynamic_cast<ExcREXS*>(BaseClass_ptr1)) {
                buffer >> element->vrmax;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_ExcREXS_vrmin(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(ExcREXS* element = dynamic_cast<ExcREXS*>(BaseClass_ptr1)) {
                buffer >> element->vrmin;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

bool assign_ExcREXS_xc(std::stringstream &buffer, BaseClass* BaseClass_ptr1) {
	if(ExcREXS* element = dynamic_cast<ExcREXS*>(BaseClass_ptr1)) {
                buffer >> element->xc;
                if(buffer.fail())
                        return false;
                else
                        return true;
        }
        else
                return false;
}

namespace CIMPP {
	BaseClass* ExcREXS_factory() {
		return new ExcREXS;
	}
}

void ExcREXS::addConstructToMap(std::unordered_map<std::string, BaseClass* (*)()>& factory_map) {
	factory_map.insert(std::make_pair(std::string("cim:ExcREXS"), &ExcREXS_factory));
}

void ExcREXS::addPrimitiveAssignFnsToMap(std::unordered_map<std::string, assign_function>& assign_map) {
	assign_map.insert(std::make_pair(std::string("cim:ExcREXS.e1"), &assign_ExcREXS_e1));
	assign_map.insert(std::make_pair(std::string("cim:ExcREXS.e2"), &assign_ExcREXS_e2));
	assign_map.insert(std::make_pair(std::string("cim:ExcREXS.fbf"), &assign_ExcREXS_fbf));
	assign_map.insert(std::make_pair(std::string("cim:ExcREXS.flimf"), &assign_ExcREXS_flimf));
	assign_map.insert(std::make_pair(std::string("cim:ExcREXS.kc"), &assign_ExcREXS_kc));
	assign_map.insert(std::make_pair(std::string("cim:ExcREXS.kd"), &assign_ExcREXS_kd));
	assign_map.insert(std::make_pair(std::string("cim:ExcREXS.ke"), &assign_ExcREXS_ke));
	assign_map.insert(std::make_pair(std::string("cim:ExcREXS.kefd"), &assign_ExcREXS_kefd));
	assign_map.insert(std::make_pair(std::string("cim:ExcREXS.kf"), &assign_ExcREXS_kf));
	assign_map.insert(std::make_pair(std::string("cim:ExcREXS.kh"), &assign_ExcREXS_kh));
	assign_map.insert(std::make_pair(std::string("cim:ExcREXS.kii"), &assign_ExcREXS_kii));
	assign_map.insert(std::make_pair(std::string("cim:ExcREXS.kip"), &assign_ExcREXS_kip));
	assign_map.insert(std::make_pair(std::string("cim:ExcREXS.ks"), &assign_ExcREXS_ks));
	assign_map.insert(std::make_pair(std::string("cim:ExcREXS.kvi"), &assign_ExcREXS_kvi));
	assign_map.insert(std::make_pair(std::string("cim:ExcREXS.kvp"), &assign_ExcREXS_kvp));
	assign_map.insert(std::make_pair(std::string("cim:ExcREXS.kvphz"), &assign_ExcREXS_kvphz));
	assign_map.insert(std::make_pair(std::string("cim:ExcREXS.nvphz"), &assign_ExcREXS_nvphz));
	assign_map.insert(std::make_pair(std::string("cim:ExcREXS.se1"), &assign_ExcREXS_se1));
	assign_map.insert(std::make_pair(std::string("cim:ExcREXS.se2"), &assign_ExcREXS_se2));
	assign_map.insert(std::make_pair(std::string("cim:ExcREXS.ta"), &assign_ExcREXS_ta));
	assign_map.insert(std::make_pair(std::string("cim:ExcREXS.tb1"), &assign_ExcREXS_tb1));
	assign_map.insert(std::make_pair(std::string("cim:ExcREXS.tb2"), &assign_ExcREXS_tb2));
	assign_map.insert(std::make_pair(std::string("cim:ExcREXS.tc1"), &assign_ExcREXS_tc1));
	assign_map.insert(std::make_pair(std::string("cim:ExcREXS.tc2"), &assign_ExcREXS_tc2));
	assign_map.insert(std::make_pair(std::string("cim:ExcREXS.te"), &assign_ExcREXS_te));
	assign_map.insert(std::make_pair(std::string("cim:ExcREXS.tf"), &assign_ExcREXS_tf));
	assign_map.insert(std::make_pair(std::string("cim:ExcREXS.tf1"), &assign_ExcREXS_tf1));
	assign_map.insert(std::make_pair(std::string("cim:ExcREXS.tf2"), &assign_ExcREXS_tf2));
	assign_map.insert(std::make_pair(std::string("cim:ExcREXS.tp"), &assign_ExcREXS_tp));
	assign_map.insert(std::make_pair(std::string("cim:ExcREXS.vcmax"), &assign_ExcREXS_vcmax));
	assign_map.insert(std::make_pair(std::string("cim:ExcREXS.vfmax"), &assign_ExcREXS_vfmax));
	assign_map.insert(std::make_pair(std::string("cim:ExcREXS.vfmin"), &assign_ExcREXS_vfmin));
	assign_map.insert(std::make_pair(std::string("cim:ExcREXS.vimax"), &assign_ExcREXS_vimax));
	assign_map.insert(std::make_pair(std::string("cim:ExcREXS.vrmax"), &assign_ExcREXS_vrmax));
	assign_map.insert(std::make_pair(std::string("cim:ExcREXS.vrmin"), &assign_ExcREXS_vrmin));
	assign_map.insert(std::make_pair(std::string("cim:ExcREXS.xc"), &assign_ExcREXS_xc));
}

void ExcREXS::addClassAssignFnsToMap(std::unordered_map<std::string, class_assign_function>& assign_map) {
																																				}

const char ExcREXS::debugName[] = "ExcREXS";
const char* ExcREXS::debugString()
{
	return ExcREXS::debugName;
}

const BaseClassDefiner ExcREXS::declare()
{
	return BaseClassDefiner(ExcREXS::addConstructToMap, ExcREXS::addPrimitiveAssignFnsToMap, ExcREXS::addClassAssignFnsToMap, ExcREXS::debugName);
}


